rubocop 0.51.0 → 0.52.0

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

@@ -7,11 +7,13 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  if x == nil
+      #   # bad
+      #   if x == nil
+      #   end
       #
-      #  # good
-      #  if x.nil?
+      #   # good
+      #   if x.nil?
+      #   end
       class NilComparison < Cop
         MSG = 'Prefer the use of the `nil?` predicate.'.freeze
 
@@ -23,8 +25,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           new_code = node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
           ->(corrector) { corrector.replace(node.source_range, new_code) }

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

@@ -7,22 +7,25 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  if x != nil
+      #   # bad
+      #   if x != nil
+      #   end
       #
-      #  # good (when not allowing semantic changes)
-      #  # bad (when allowing semantic changes)
-      #  if !x.nil?
+      #   # good (when not allowing semantic changes)
+      #   # bad (when allowing semantic changes)
+      #   if !x.nil?
+      #   end
       #
-      #  # good (when allowing semantic changes)
-      #  if x
+      #   # good (when allowing semantic changes)
+      #   if x
+      #   end
       #
       # Non-nil checks are allowed if they are the final nodes of predicate.
       #
-      #  # good
-      #  def signed_in?
-      #    !current_user.nil?
-      #  end
+      #   # good
+      #   def signed_in?
+      #     !current_user.nil?
+      #   end
       class NonNilCheck < Cop
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
@@ -53,6 +56,17 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def autocorrect(node)
+          case node.method_name
+          when :!=
+            autocorrect_comparison(node)
+          when :!
+            autocorrect_non_nil(node, node.receiver)
+          when :nil?
+            autocorrect_unless_nil(node, node.receiver)
+          end
+        end
+
         private
 
         def unless_and_nil_check?(send_node)
@@ -74,17 +88,6 @@ module RuboCop
           cop_config['IncludeSemanticChanges']
         end
 
-        def autocorrect(node)
-          case node.method_name
-          when :!=
-            autocorrect_comparison(node)
-          when :!
-            autocorrect_non_nil(node, node.receiver)
-          when :nil?
-            autocorrect_unless_nil(node, node.receiver)
-          end
-        end
-
         def autocorrect_comparison(node)
           expr = node.source
 

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

@@ -3,7 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses if the keyword *not* instead of !.
+      # This cop checks for uses of the keyword `not` instead of `!`.
+      #
+      # @example
+      #
+      #   # bad - parentheses are required because of op precedence
+      #   x = (not something)
+      #
+      #   # good
+      #   x = !something
+      #
       class Not < Cop
         MSG = 'Use `!` instead of `not`.'.freeze
 
@@ -22,10 +31,9 @@ module RuboCop
           add_offense(node, location: :selector)
         end
 
-        private
-
         def autocorrect(node)
-          range = range_with_surrounding_space(node.loc.selector, :right)
+          range = range_with_surrounding_space(range: node.loc.selector,
+                                               side: :right)
 
           if opposite_method?(node.receiver)
             correct_opposite_method(range, node.receiver)
@@ -36,6 +44,8 @@ module RuboCop
           end
         end
 
+        private
+
         def opposite_method?(child)
           child.send_type? && OPPOSITE_METHODS.key?(child.method_name)
         end

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

@@ -33,12 +33,6 @@ module RuboCop
           add_offense(node)
         end
 
-        private
-
-        def message(node)
-          self.class.const_get("#{literal_type(node).upcase}_MSG")
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             type = literal_type(node)
@@ -47,6 +41,12 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          self.class.const_get("#{literal_type(node).upcase}_MSG")
+        end
+
         def literal_type(node)
           literal = integer_part(node)
 

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

@@ -41,6 +41,12 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, format_number(node))
+          end
+        end
+
         private
 
         def max_parameter_name
@@ -68,12 +74,6 @@ module RuboCop
           cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, format_number(node))
-          end
-        end
-
         def format_number(node)
           int_part, float_part = node.source.split('.')
           int_part = int_part.to_i
@@ -86,7 +86,7 @@ module RuboCop
           formatted_int.insert(0, '-') if int_part < 0
 
           if float_part
-            format('%s.%s', formatted_int, float_part)
+            format('%<int>s.%<float>s', int: formatted_int, float: float_part)
           else
             formatted_int
           end

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

@@ -16,10 +16,7 @@ module RuboCop
       # populated with objects which can be compared with integers, but are
       # not themselves `Interger` polymorphic.
       #
-      # @example
-      #
-      #   # EnforcedStyle: predicate (default)
-      #
+      # @example EnforcedStyle: predicate (default)
       #   # bad
       #
       #   foo == 0
@@ -32,10 +29,7 @@ module RuboCop
       #   foo.negative?
       #   bar.baz.positive?
       #
-      # @example
-      #
-      #   # EnforcedStyle: comparison
-      #
+      # @example EnforcedStyle: comparison
       #   # bad
       #
       #   foo.zero?
@@ -50,7 +44,7 @@ module RuboCop
       class NumericPredicate < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
         REPLACEMENTS = {
           'zero?' => '==',
@@ -64,7 +58,17 @@ module RuboCop
           return unless numeric
 
           add_offense(node,
-                      message: format(MSG, replacement, node.source))
+                      message: format(MSG,
+                                      prefer: replacement,
+                                      current: node.source))
+        end
+
+        def autocorrect(node)
+          _, replacement = check(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement)
+          end
         end
 
         private
@@ -82,14 +86,6 @@ module RuboCop
           [numeric, replacement(numeric, operator)]
         end
 
-        def autocorrect(node)
-          _, replacement = check(node)
-
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
-          end
-        end
-
         def replacement(numeric, operation)
           if style == :predicate
             [parenthesized_source(numeric),

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

@@ -9,7 +9,7 @@ module RuboCop
         include OnNormalIfUnless
 
         MSG = 'Favor the ternary operator (`?:`) ' \
-              'over `%s/then/else/end` constructs.'.freeze
+              'over `%<keyword>s/then/else/end` constructs.'.freeze
 
         def on_normal_if_unless(node)
           return unless node.single_line? && node.else_branch
@@ -17,16 +17,16 @@ module RuboCop
           add_offense(node)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.source_range, replacement(node))
           end
         end
 
+        private
+
         def message(node)
-          format(MSG, node.keyword)
+          format(MSG, keyword: node.keyword)
         end
 
         def replacement(node)

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

@@ -7,32 +7,29 @@ module RuboCop
       # current Ruby version supports keyword arguments.
       #
       # @example
-      #   Instead of:
       #
+      #   # bad
       #   def fry(options = {})
       #     temperature = options.fetch(:temperature, 300)
-      #     ...
+      #     # ...
       #   end
       #
-      #   Prefer:
       #
+      #   # good
       #   def fry(temperature: 300)
-      #     ...
+      #     # ...
       #   end
       class OptionHash < Cop
         MSG = 'Prefer keyword arguments to options hashes.'.freeze
 
-        def on_args(node)
-          *_but_last, last_arg = *node
-
-          return unless last_arg && last_arg.optarg_type?
-
-          arg, default_value = *last_arg
+        def_node_matcher :option_hash, <<-PATTERN
+          (args ... $(optarg [#suspicious_name? _] (hash)))
+        PATTERN
 
-          return unless default_value.hash_type? && default_value.pairs.empty?
-          return unless suspicious_name?(arg)
-
-          add_offense(last_arg)
+        def on_args(node)
+          option_hash(node) do |options|
+            add_offense(options)
+          end
         end
 
         private

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

@@ -58,8 +58,6 @@ module RuboCop
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn
 
-        private
-
         def autocorrect(node)
           if ternary_assignment?(node)
             variable, default = take_variable_and_default_from_ternary(node)
@@ -73,6 +71,8 @@ module RuboCop
           end
         end
 
+        private
+
         def take_variable_and_default_from_ternary(node)
           variable, if_statement = *node
           [variable, if_statement.else_branch]

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

@@ -38,6 +38,19 @@ module RuboCop
           add_offense(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            left, right = *node
+            left_elements = *left
+            right_elements = [*right].compact
+            order = find_valid_order(left_elements, right_elements)
+            correction = assignment_corrector(node, order)
+
+            corrector.replace(correction.correction_range,
+                              correction.correction)
+          end
+        end
+
         private
 
         def allowed_masign?(lhs_elements, rhs_elements)
@@ -68,19 +81,6 @@ module RuboCop
           node.block_type? || node.send_type?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            left, right = *node
-            left_elements = *left
-            right_elements = [*right].compact
-            order = find_valid_order(left_elements, right_elements)
-            correction = assignment_corrector(node, order)
-
-            corrector.replace(correction.correction_range,
-                              correction.correction)
-          end
-        end
-
         def assignment_corrector(node, order)
           _assignment, modifier = *node.parent
           if modifier_statement?(node.parent)

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
@@ -31,7 +48,7 @@ module RuboCop
 
           control_op_condition(cond) do |first_child|
             return if modifier_op?(first_child)
-            return if parens_required?(node.children.first)
+            return if parens_required?(node.condition)
             return if safe_assignment?(cond) && safe_assignment_allowed?
 
             add_offense(cond)
@@ -42,8 +59,7 @@ module RuboCop
           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)

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,10 +66,13 @@ 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)
         end
@@ -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