rubocop 0.49.1 → 0.50.0

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

@@ -39,14 +39,14 @@ module RuboCop
           return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
                     frozen_string_literals_enabled?
 
-          add_offense(value, :expression)
+          add_offense(value)
         end
 
         def autocorrect(node)
           expr = node.source_range
 
           lambda do |corrector|
-            if unbracketed_array?(node)
+            if node.array_type? && !node.bracketed?
               corrector.insert_before(expr, '[')
               corrector.insert_after(expr, '].freeze')
             else
@@ -55,10 +55,6 @@ 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

@@ -82,21 +82,25 @@ module RuboCop
 
         def on_if(node)
           return if node.elsif? || node.ternary?
-          return if style == :prefix && node.modifier_form?
-          return if style == :postfix && !node.modifier_form?
+          return if correct_style?(node)
 
           check_negative_conditional(node)
         end
 
+        private
+
         def message(node)
           format(MSG, node.inverse_keyword, node.keyword)
         end
 
-        private
-
         def autocorrect(node)
           negative_conditional_corrector(node)
         end
+
+        def correct_style?(node)
+          style == :prefix && node.modifier_form? ||
+            style == :postfix && !node.modifier_form?
+        end
       end
     end
   end

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

@@ -14,9 +14,6 @@ module RuboCop
       #   method1(method2 arg, method3, arg)
       class NestedParenthesizedCalls < Cop
         MSG = 'Add parentheses to nested method call `%s`.'.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 node.parenthesized?
@@ -33,13 +30,12 @@ module RuboCop
         def allowed_omission?(send_node)
           !send_node.arguments? || send_node.parenthesized? ||
             send_node.setter_method? || send_node.operator_method? ||
-            rspec_matcher?(send_node)
+            whitelisted?(send_node)
         end
 
-        # 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) &&
+        def whitelisted?(send_node)
+          send_node.parent.arguments.one? &&
+            whitelisted_methods.include?(send_node.method_name.to_s) &&
             send_node.arguments.one?
         end
 
@@ -55,6 +51,10 @@ module RuboCop
             corrector.insert_after(last_arg, ')')
           end
         end
+
+        def whitelisted_methods
+          cop_config['Whitelist'] || []
+        end
       end
     end
   end

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

@@ -12,7 +12,7 @@ module RuboCop
           return unless node.ternary?
 
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
-            add_offense(nested_ternary, :expression)
+            add_offense(nested_ternary)
           end
         end
       end

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

@@ -24,8 +24,6 @@ module RuboCop
       #    !current_user.nil?
       #  end
       class NonNilCheck < Cop
-        include OnMethodDef
-
         def_node_matcher :not_equal_to_nil?, '(send _ :!= (:nil))'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
         def_node_matcher :nil_check?, '(send _ :nil?)'
@@ -38,9 +36,22 @@ module RuboCop
             add_offense(node, :selector)
           elsif include_semantic_changes? &&
                 (not_and_nil_check?(node) || unless_and_nil_check?(node))
-            add_offense(node, :expression)
+            add_offense(node)
+          end
+        end
+
+        def on_def(node)
+          body = node.body
+
+          return unless node.predicate_method? && body
+
+          if body.begin_type?
+            ignore_node(body.children.last)
+          else
+            ignore_node(body)
           end
         end
+        alias on_defs on_def
 
         private
 
@@ -63,17 +74,6 @@ module RuboCop
           cop_config['IncludeSemanticChanges']
         end
 
-        def on_method_def(_node, name, _args, body)
-          # only predicate methods are handled differently
-          return unless name.to_s.end_with?('?') && body
-
-          if body.begin_type?
-            ignore_node(body.children.last)
-          else
-            ignore_node(body)
-          end
-        end
-
         def autocorrect(node)
           case node.method_name
           when :!=

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

@@ -27,14 +27,18 @@ module RuboCop
 
         def on_int(node)
           type = literal_type(node)
+
           return unless type
 
-          msg = self.class.const_get("#{type.upcase}_MSG")
-          add_offense(node, :expression, msg)
+          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)

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

@@ -56,9 +56,9 @@ module RuboCop
 
           case int
           when /^\d+$/
-            add_offense(node, :expression) { self.max = int.size + 1 }
+            add_offense(node) { self.max = int.size + 1 }
           when /\d{4}/, short_group_regex
-            add_offense(node, :expression) do
+            add_offense(node) do
               self.config_to_allow_offenses = { 'Enabled' => false }
             end
           end

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

@@ -8,10 +8,14 @@ module RuboCop
       # These can be replaced by their respective predicate methods.
       # The cop can also be configured to do the reverse.
       #
-      # The cop disregards `nonzero?` as it its value is truthy or falsey,
+      # The cop disregards `#nonzero?` as it its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #
+      # The cop ignores comparisons to global variables, since they are often
+      # populated with objects which can be compared with integers, but are
+      # not themselves `Interger` polymorphic.
+      #
       # @example
       #
       #   # EnforcedStyle: predicate (default)
@@ -59,7 +63,7 @@ module RuboCop
 
           return unless numeric
 
-          add_offense(node, node.loc.expression,
+          add_offense(node, :expression,
                       format(MSG, replacement, node.source))
         end
 
@@ -128,11 +132,11 @@ module RuboCop
         PATTERN
 
         def_node_matcher :comparison, <<-PATTERN
-          (send $(...) ${:== :> :<} (int 0))
+          (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
         PATTERN
 
         def_node_matcher :inverted_comparison, <<-PATTERN
-          (send (int 0) ${:== :> :<} $(...))
+          (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
       end
     end

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

@@ -14,15 +14,21 @@ module RuboCop
         def on_normal_if_unless(node)
           return unless node.single_line? && node.else_branch
 
-          add_offense(node, :expression, format(MSG, node.keyword))
+          add_offense(node)
         end
 
+        private
+
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.source_range, replacement(node))
           end
         end
 
+        def message(node)
+          format(MSG, node.keyword)
+        end
+
         def replacement(node)
           return to_ternary(node) unless node.parent
 
@@ -56,8 +62,7 @@ module RuboCop
         end
 
         def method_call_with_changed_precedence?(node)
-          return false unless node.send_type?
-          return false if node.method_args.empty?
+          return false unless node.send_type? && node.arguments?
           return false if parenthesized_call?(node)
 
           !operator?(node.method_name)

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

@@ -32,7 +32,7 @@ module RuboCop
           return unless default_value.hash_type? && default_value.pairs.empty?
           return unless suspicious_name?(arg)
 
-          add_offense(last_arg, :expression, MSG)
+          add_offense(last_arg)
         end
 
         def validate_config

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

@@ -26,8 +26,7 @@ module RuboCop
           arguments = *arguments
 
           each_misplaced_optional_arg(arguments) do |argument|
-            arg, = *argument
-            add_offense(argument, :expression, format(MSG, arg))
+            add_offense(argument)
           end
         end
 

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for potential usage of the `||=` operator.
+      #
+      # @example
+      #   # bad
+      #   name = name ? name : 'Bozhidar'
+      #
+      #   # bad
+      #   name = if name
+      #            name
+      #          else
+      #            'Bozhidar'
+      #          end
+      #
+      #   # bad
+      #   unless name
+      #     name = 'Bozhidar'
+      #   end
+      #
+      #   # bad
+      #   name = 'Bozhidar' unless name
+      #
+      #   # good - set name to 'Bozhidar', only if it's nil or false
+      #   name ||= 'Bozhidar'
+      class OrAssignment < Cop
+        MSG = 'Use the double pipe equals operator `||=` instead.'.freeze
+
+        def_node_matcher :ternary_assignment?, <<-PATTERN
+          ({lvasgn ivasgn cvasgn gvasgn} _var
+            (if
+              ({lvar ivar cvar gvar} _var)
+              ({lvar ivar cvar gvar} _var)
+              _))
+        PATTERN
+
+        def_node_matcher :unless_assignment?, <<-PATTERN
+          (if
+            ({lvar ivar cvar gvar} _var) nil
+            ({lvasgn ivasgn cvasgn gvasgn} _var
+              _))
+        PATTERN
+
+        def on_if(node)
+          return unless unless_assignment?(node)
+          add_offense(node)
+        end
+
+        def on_lvasgn(node)
+          return unless ternary_assignment?(node)
+          add_offense(node)
+        end
+
+        alias on_ivasgn on_lvasgn
+        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)
+          else
+            variable, default = take_variable_and_default_from_unless(node)
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range,
+                              "#{variable} ||= #{default.source}")
+          end
+        end
+
+        def take_variable_and_default_from_ternary(node)
+          variable, if_statement = *node
+          [variable, if_statement.else_branch]
+        end
+
+        def take_variable_and_default_from_unless(node)
+          variable, default = *node.if_branch
+          [variable, default]
+        end
+      end
+    end
+  end
+end

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

@@ -35,7 +35,7 @@ module RuboCop
           return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
                     allowed_masign?(lhs_elements, rhs_elements)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         private
@@ -159,7 +159,7 @@ module RuboCop
           def accesses?(rhs, lhs)
             if lhs.method?(:[]=)
               matching_calls(rhs, lhs.receiver, :[]).any? do |args|
-                args == lhs.method_args
+                args == lhs.arguments
               end
             else
               access_method = lhs.method_name.to_s.chop.to_sym

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

@@ -18,23 +18,24 @@ 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.children.first)
+            return if safe_assignment?(cond) && safe_assignment_allowed?
 
-          add_offense(cond, :expression, message(node))
+            add_offense(cond)
+          end
         end
 
         def modifier_op?(node)
@@ -46,7 +47,7 @@ module RuboCop
         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

@@ -73,7 +73,7 @@ module RuboCop
           return if uses_preferred_delimiter?(node, type) ||
                     contains_preferred_delimiter?(node, type)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def uses_preferred_delimiter?(node, type)

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

@@ -25,7 +25,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, :begin)
         end
 
         def correct_literal_style?(node)
@@ -33,7 +33,7 @@ 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