rubocop 0.47.1 → 0.48.0

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

@@ -46,7 +46,7 @@ module RuboCop
           expr = node.source_range
 
           lambda do |corrector|
-            if node.array_type? && !node.square_brackets?
+            if unbracketed_array?(node)
               corrector.insert_before(expr, '[')
               corrector.insert_after(expr, '].freeze')
             else
@@ -55,6 +55,10 @@ module RuboCop
           end
         end
 
+        def unbracketed_array?(node)
+          node.array_type? && !node.square_brackets? && !node.percent_literal?
+        end
+
         def_node_matcher :splat_value, <<-PATTERN
           (array (splat $_))
         PATTERN

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

@@ -4,14 +4,86 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of if with a negated condition. Only ifs
-      # without else are considered.
+      # without else are considered. There are three different styles:
+      #
+      #   - both
+      #   - prefix
+      #   - postfix
+      #
+      # @example
+      #
+      #   # EnforcedStyle: both
+      #   # enforces `unless` for `prefix` and `postfix` conditionals
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      # @example
+      #
+      #   # EnforcedStyle: prefix
+      #   # enforces `unless` for just `prefix` conditionals
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   bar if !foo
+      #
+      # @example
+      #
+      #   # EnforcedStyle: postfix
+      #   # enforces `unless` for just `postfix` conditionals
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   if !foo
+      #     bar
+      #   end
       class NegatedIf < Cop
+        include ConfigurableEnforcedStyle
         include NegativeConditional
 
         MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
 
         def on_if(node)
           return if node.elsif? || node.ternary?
+          return if style == :prefix && node.modifier_form?
+          return if style == :postfix && !node.modifier_form?
 
           check_negative_conditional(node)
         end

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

@@ -14,39 +14,41 @@ module RuboCop
       #   method1(method2 arg, method3, arg)
       class NestedParenthesizedCalls < Cop
         MSG = 'Add parentheses to nested method call `%s`.'.freeze
-        RSPEC_MATCHERS = [:be, :eq, :eql, :equal, :be_kind_of, :be_instance_of,
-                          :respond_to, :be_between, :match, :be_within,
-                          :start_with, :end_with, :include, :raise_error].freeze
+        RSPEC_MATCHERS = %i(be eq eql equal be_kind_of be_instance_of
+                            respond_to be_between match be_within
+                            start_with end_with include raise_error).freeze
 
         def on_send(node)
-          return unless parenthesized_call?(node)
+          return unless node.parenthesized?
 
           node.each_child_node(:send) do |nested|
-            next if nested.method_args.empty? ||
-                    parenthesized_call?(nested) ||
-                    operator?(nested.method_name) ||
-                    rspec_matcher?(node, nested) ||
-                    nested.asgn_method_call?
+            next if allowed_omission?(nested)
+
             add_offense(nested, nested.source_range, format(MSG, nested.source))
           end
         end
 
         private
 
-        def rspec_matcher?(parent, send)
-          parent.method_args.one? && # .to, .not_to, etc
-            RSPEC_MATCHERS.include?(send.method_name) &&
-            send.method_args.one?
+        def allowed_omission?(send_node)
+          !send_node.arguments? || send_node.parenthesized? ||
+            send_node.setter_method? || send_node.operator_method? ||
+            rspec_matcher?(send_node)
         end
 
-        def autocorrect(nested)
-          _scope, _method_name, *args = *nested
+        # TODO: Relegate this from RuboCop core
+        def rspec_matcher?(send_node)
+          send_node.parent.arguments.one? && # .to, .not_to, etc
+            RSPEC_MATCHERS.include?(send_node.method_name) &&
+            send_node.arguments.one?
+        end
 
-          first_arg = args.first.source_range
-          last_arg = args.last.source_range
+        def autocorrect(nested)
+          first_arg = nested.first_argument.source_range
+          last_arg = nested.last_argument.source_range
 
-          first_arg_with_space = range_with_surrounding_space(first_arg, :left)
-          leading_space = first_arg_with_space.begin.resize(1)
+          leading_space =
+            range_with_surrounding_space(first_arg, :left).begin.resize(1)
 
           lambda do |corrector|
             corrector.replace(leading_space, '(')

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

@@ -23,12 +23,12 @@ module RuboCop
         include MinBodyLength
 
         MSG = 'Use `next` to skip iteration.'.freeze
-        EXIT_TYPES = [:break, :return].freeze
+        EXIT_TYPES = %i(break return).freeze
         EACH_ = 'each_'.freeze
-        ENUMERATORS = [:collect, :collect_concat, :detect, :downto, :each,
-                       :find, :find_all, :find_index, :inject, :loop, :map!,
-                       :map, :reduce, :reject, :reject!, :reverse_each, :select,
-                       :select!, :times, :upto].freeze
+        ENUMERATORS = %i(collect collect_concat detect downto each
+                         find find_all find_index inject loop map!
+                         map reduce reject reject! reverse_each select
+                         select! times upto).freeze
 
         def investigate(_processed_source)
           # When correcting nested offenses, we need to keep track of how much

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

@@ -46,13 +46,13 @@ module RuboCop
 
         def unless_and_nil_check?(send_node)
           parent = send_node.parent
+
           nil_check?(send_node) && unless_check?(parent) && !parent.ternary? &&
             parent.unless?
         end
 
         def message(node)
-          _receiver, method, _args = *node
-          if method == :!=
+          if node.method?(:!=)
             'Prefer `!expression.nil?` over `expression != nil`.'
           else
             'Explicit non-nil checks are usually redundant.'
@@ -75,15 +75,13 @@ module RuboCop
         end
 
         def autocorrect(node)
-          receiver, method, _args = *node
-
-          case method
+          case node.method_name
           when :!=
             autocorrect_comparison(node)
           when :!
-            autocorrect_non_nil(node, receiver)
+            autocorrect_non_nil(node, node.receiver)
           when :nil?
-            autocorrect_unless_nil(node, receiver)
+            autocorrect_unless_nil(node, node.receiver)
           end
         end
 
@@ -103,9 +101,8 @@ module RuboCop
 
         def autocorrect_non_nil(node, inner_node)
           lambda do |corrector|
-            receiver, _method, _args = *inner_node
-            if receiver
-              corrector.replace(node.source_range, receiver.source)
+            if inner_node.receiver
+              corrector.replace(node.source_range, inner_node.receiver.source)
             else
               corrector.replace(node.source_range, 'self')
             end

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

@@ -26,11 +26,10 @@ module RuboCop
 
         def autocorrect(node)
           range = range_with_surrounding_space(node.loc.selector, :right)
-          child = node.children.first
 
-          if opposite_method?(child)
-            correct_opposite_method(range, child)
-          elsif requires_parens?(child)
+          if opposite_method?(node.receiver)
+            correct_opposite_method(range, node.receiver)
+          elsif requires_parens?(node.receiver)
             correct_with_parens(range, node)
           else
             correct_without_parens(range)

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

@@ -5,6 +5,24 @@ module RuboCop
     module Style
       # This cop checks for big numeric literals without _ between groups
       # of digits in them.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   1000000
+      #   1_00_000
+      #   1_0000
+      #
+      #   # good
+      #
+      #   1_000_000
+      #   1000
+      #
+      #   # good unless Strict is set
+      #
+      #   10_000_00 # typical representation of $10,000 in cents
+      #
       class NumericLiterals < Cop
         # The parameter is called MinDigits (meaning the minimum number of
         # digits for which an offense can be registered), but essentially it's
@@ -12,8 +30,8 @@ module RuboCop
         include ConfigurableMax
         include IntegerNode
 
-        MSG = 'Separate every 3 digits in the integer portion of a number ' \
-              'with underscores(_).'.freeze
+        MSG = 'Use underscores(_) as decimal mark and ' \
+              'separate every 3 digits with them.'.freeze
 
         def on_int(node)
           check(node)
@@ -39,13 +57,17 @@ module RuboCop
           case int
           when /^\d+$/
             add_offense(node, :expression) { self.max = int.size + 1 }
-          when /\d{4}/, /_\d{1,2}(_|$)/
+          when /\d{4}/, short_group_regex
             add_offense(node, :expression) do
               self.config_to_allow_offenses = { 'Enabled' => false }
             end
           end
         end
 
+        def short_group_regex
+          cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
+        end
+
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.source_range, format_number(node))

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

@@ -108,7 +108,7 @@ module RuboCop
         end
 
         def replacement_supported?(operator)
-          if [:>, :<].include?(operator)
+          if %i(> <).include?(operator)
             target_ruby_version >= 2.3
           else
             true

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

@@ -26,7 +26,7 @@ module RuboCop
         def replacement(node)
           return to_ternary(node) unless node.parent
 
-          if [:and, :or].include?(node.parent.type)
+          if %i(and or).include?(node.parent.type)
             return "(#{to_ternary(node)})"
           end
 
@@ -48,7 +48,7 @@ module RuboCop
         end
 
         def requires_parentheses?(node)
-          return true if [:and, :or, :if].include?(node.type)
+          return true if %i(and or if).include?(node.type)
           return true if node.assignment?
           return true if method_call_with_changed_precedence?(node)
 

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

@@ -17,8 +17,8 @@ module RuboCop
         MSG = 'When defining the `%s` operator, ' \
               'name its argument `other`.'.freeze
 
-        OP_LIKE_METHODS = [:eql?, :equal?].freeze
-        BLACKLISTED = [:+@, :-@, :[], :[]=, :<<, :`].freeze
+        OP_LIKE_METHODS = %i(eql? equal?).freeze
+        BLACKLISTED = %i(+@ -@ [] []= << `).freeze
 
         def_node_matcher :op_method_candidate?, <<-PATTERN
           (def $_ (args $(arg [!:other !:_other])) _)

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

@@ -23,6 +23,8 @@ module RuboCop
       #   b = 2
       #   c = 3
       class ParallelAssignment < Cop
+        include RescueNode
+
         MSG = 'Do not use parallel assignment.'.freeze
 
         def on_masgn(node)
@@ -80,9 +82,10 @@ module RuboCop
         end
 
         def assignment_corrector(node, order)
+          _assignment, modifier = *node.parent
           if modifier_statement?(node.parent)
             ModifierCorrector.new(node, config, order)
-          elsif rescue_modifier?(node.parent)
+          elsif rescue_modifier?(modifier)
             RescueCorrector.new(node, config, order)
           else
             GenericCorrector.new(node, config, order)
@@ -149,7 +152,7 @@ module RuboCop
           # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.
           # Does `rhs` access the same value which is assigned by `lhs`?
           def accesses?(rhs, lhs)
-            if lhs.method_name == :[]=
+            if lhs.method?(:[]=)
               matching_calls(rhs, lhs.receiver, :[]).any? do |args|
                 args == lhs.method_args
               end
@@ -172,7 +175,7 @@ module RuboCop
             node.modifier_form?
         end
 
-        def rescue_modifier?(node)
+        def rescue_modifier_old?(node)
           node && node.rescue_type? &&
             (node.parent.nil? || !(node.parent.kwbegin_type? ||
             node.parent.ensure_type?))

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

@@ -4,9 +4,30 @@ module RuboCop
   module Cop
     module Style
       # This cop enforces the consistent usage of `%`-literal delimiters.
+      #
+      # Specify the 'default' key to set all preferred delimiters at once. You
+      # can continue to specify individual preferred delimiters to override the
+      # default.
+      #
+      # @example
+      #   # Style/PercentLiteralDelimiters:
+      #   #   PreferredDelimiters:
+      #   #     default: ()
+      #   #     %i:      []
+      #
+      #   # good
+      #   %w(alpha beta) + %i[gamma delta]
+      #
+      #   # bad
+      #   %W[alpha #{beta}]
+      #
+      #   # bad
+      #   %I[alpha beta]
       class PercentLiteralDelimiters < Cop
         include PercentLiteral
 
+        PERCENT_LITERAL_TYPES = %w(% %i %I %q %Q %r %s %w %W %x).freeze
+
         def on_array(node)
           process(node, '%w', '%W', '%i', '%I')
         end
@@ -30,7 +51,7 @@ module RuboCop
 
         def message(node)
           type = type(node)
-          delimiters = preferred_delimiters(type)
+          delimiters = preferred_delimiters_for(type)
 
           "`#{type}`-literals should be delimited by " \
           "`#{delimiters[0]}` and `#{delimiters[1]}`."
@@ -41,7 +62,7 @@ module RuboCop
         def autocorrect(node)
           type = type(node)
 
-          opening_delimiter, closing_delimiter = preferred_delimiters(type)
+          opening_delimiter, closing_delimiter = preferred_delimiters_for(type)
 
           lambda do |corrector|
             corrector.replace(node.loc.begin, "#{type}#{opening_delimiter}")
@@ -57,16 +78,41 @@ module RuboCop
           add_offense(node, :expression)
         end
 
-        def preferred_delimiters(type)
-          cop_config['PreferredDelimiters'][type].split(//)
+        def preferred_delimiters
+          @preferred_delimiters ||=
+            begin
+              ensure_valid_preferred_delimiters
+
+              if cop_config['PreferredDelimiters'].key?('default')
+                Hash[PERCENT_LITERAL_TYPES.map do |type|
+                  [type, cop_config['PreferredDelimiters'][type] ||
+                    cop_config['PreferredDelimiters']['default']]
+                end]
+              else
+                cop_config['PreferredDelimiters']
+              end
+            end
+        end
+
+        def ensure_valid_preferred_delimiters
+          invalid = cop_config['PreferredDelimiters'].keys -
+                    (PERCENT_LITERAL_TYPES + %w(default))
+          return if invalid.empty?
+
+          raise ArgumentError,
+                "Invalid preferred delimiter config key: #{invalid.join(', ')}"
+        end
+
+        def preferred_delimiters_for(type)
+          preferred_delimiters[type].split(//)
         end
 
         def uses_preferred_delimiter?(node, type)
-          preferred_delimiters(type)[0] == begin_source(node)[-1]
+          preferred_delimiters_for(type)[0] == begin_source(node)[-1]
         end
 
         def contains_preferred_delimiter?(node, type)
-          preferred_delimiters = preferred_delimiters(type)
+          preferred_delimiters = preferred_delimiters_for(type)
           node
             .children.map { |n| string_source(n) }.compact
             .any? { |s| preferred_delimiters.any? { |d| s.include?(d) } }