rubocop 0.46.0 → 0.47.0

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

@@ -18,28 +18,13 @@ module RuboCop
         end
 
         def message(node)
-          if node.while_type?
-            format(MSG, 'until', 'while')
-          else
-            format(MSG, 'while', 'until')
-          end
+          format(MSG, node.inverse_keyword, node.keyword)
         end
 
         private
 
         def autocorrect(node)
-          lambda do |corrector|
-            condition, _body, _rest = *node
-            # Look inside parentheses around the condition, if any.
-            condition, = *condition while condition.begin_type?
-            # Unwrap the negated portion of the condition (a send node).
-            pos_condition, _method, = *condition
-            corrector.replace(
-              node.loc.keyword,
-              node.while_type? ? 'until' : 'while'
-            )
-            corrector.replace(condition.source_range, pos_condition.source)
-          end
+          negative_conditional_corrector(node)
         end
       end
     end

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

@@ -14,8 +14,6 @@ module RuboCop
       #   # good
       #   something if b && a
       class NestedModifier < Cop
-        include IfNode
-
         MSG = 'Avoid using nested modifiers.'.freeze
 
         def on_while(node)
@@ -32,54 +30,33 @@ module RuboCop
 
         def check(node)
           return if part_of_ignored_node?(node)
-          return unless modifier?(node)
-
-          ancestor = node.ancestors.first
-          return unless ancestor &&
-                        [:if, :while, :until].include?(ancestor.type) &&
-                        modifier?(ancestor)
+          return unless modifier?(node) && modifier?(node.parent)
 
           add_offense(node, :keyword)
           ignore_node(node)
         end
 
         def modifier?(node)
-          modifier_if?(node) || modifier_while_or_until?(node)
-        end
-
-        def modifier_while_or_until?(node)
-          node.loc.respond_to?(:keyword) &&
-            %w(while until).include?(node.loc.keyword.source) &&
-            node.modifier_form?
+          node && MODIFIER_NODES.include?(node.type) && node.modifier_form?
         end
 
         def autocorrect(node)
-          return unless node.if_type?
-
-          ancestor = node.ancestors.first
-          return unless ancestor.if_type?
+          return unless node.if_type? && node.parent.if_type?
 
-          autocorrect_if_unless(ancestor, node)
-        end
-
-        def autocorrect_if_unless(outer_node, inner_node)
-          outer_cond, = *outer_node
-
-          range = range_between(inner_node.loc.keyword.begin_pos,
-                                outer_cond.source_range.end_pos)
+          range = range_between(node.loc.keyword.begin_pos,
+                                node.parent.condition.source_range.end_pos)
 
           lambda do |corrector|
-            corrector.replace(range, new_expression(outer_node, inner_node))
+            corrector.replace(range, new_expression(node.parent, node))
           end
         end
 
         def new_expression(outer_node, inner_node)
-          outer_keyword = outer_node.loc.keyword.source
-          operator = replacement_operator(outer_keyword)
+          operator = replacement_operator(outer_node.keyword)
           lh_operand = left_hand_operand(outer_node, operator)
-          rh_operand = right_hand_operand(inner_node, outer_keyword)
+          rh_operand = right_hand_operand(inner_node, outer_node.keyword)
 
-          "#{outer_keyword} #{lh_operand} #{operator} #{rh_operand}"
+          "#{outer_node.keyword} #{lh_operand} #{operator} #{rh_operand}"
         end
 
         def replacement_operator(keyword)
@@ -87,26 +64,22 @@ module RuboCop
         end
 
         def left_hand_operand(node, operator)
-          cond, = *node
-
-          expr = cond.source
-          expr = "(#{expr})" if cond.or_type? && operator == '&&'.freeze
+          expr = node.condition.source
+          expr = "(#{expr})" if node.condition.or_type? &&
+                                operator == '&&'.freeze
           expr
         end
 
         def right_hand_operand(node, left_hand_keyword)
-          cond, = *node
-          keyword = node.loc.keyword.source
-
-          expr = cond.source
-          expr = "(#{expr})" if requires_parens?(cond)
-          expr = "!#{expr}" unless left_hand_keyword == keyword
+          expr = node.condition.source
+          expr = "(#{expr})" if requires_parens?(node.condition)
+          expr = "!#{expr}" unless left_hand_keyword == node.keyword
           expr
         end
 
         def requires_parens?(node)
           node.or_type? ||
-            !(RuboCop::Node::COMPARISON_OPERATORS & node.children).empty?
+            !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
         end
       end
     end

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

@@ -5,16 +5,14 @@ module RuboCop
     module Style
       # This cop checks for nested ternary op expressions.
       class NestedTernaryOperator < Cop
-        include IfNode
-
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
               'constructs instead.'.freeze
 
         def on_if(node)
-          return unless ternary?(node)
+          return unless node.ternary?
 
-          node.each_descendant(:if) do |nested_if_node|
-            add_offense(nested_if_node, :expression) if ternary?(nested_if_node)
+          node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
+            add_offense(nested_ternary, :expression)
           end
         end
       end

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

@@ -19,7 +19,6 @@ module RuboCop
       #     puts a
       #   end
       class Next < Cop
-        include IfNode
         include ConfigurableEnforcedStyle
         include MinBodyLength
 
@@ -50,21 +49,14 @@ module RuboCop
         end
 
         def on_while(node)
-          _, body = *node
-          return unless body && ends_with_condition?(body)
-
-          offense_node = offense_node(body)
-          add_offense(offense_node, offense_location(offense_node), MSG)
-        end
-        alias on_until on_while
+          return unless node.body && ends_with_condition?(node.body)
 
-        def on_for(node)
-          _, _, body = *node
-          return unless body && ends_with_condition?(body)
+          offending_node = offense_node(node.body)
 
-          offense_node = offense_node(body)
-          add_offense(offense_node, offense_location(offense_node), MSG)
+          add_offense(offending_node, offense_location(offending_node), MSG)
         end
+        alias on_until on_while
+        alias on_for on_while
 
         private
 
@@ -80,23 +72,33 @@ module RuboCop
         end
 
         def simple_if_without_break?(node)
-          return false unless node
           return false unless if_without_else?(node)
-          return false if style == :skip_modifier_ifs && modifier_if?(node)
-          return false if !modifier_if?(node) && !min_body_length?(node)
+          return false if if_else_children?(node)
+          return false if allowed_modifier_if?(node)
 
           !exit_body_type?(node)
         end
 
+        def allowed_modifier_if?(node)
+          if node.modifier_form?
+            style == :skip_modifier_ifs
+          else
+            !min_body_length?(node)
+          end
+        end
+
+        def if_else_children?(node)
+          node.each_child_node(:if).any?(&:else?)
+        end
+
         def if_without_else?(node)
-          node.if_type? && !ternary?(node) && !if_else?(node)
+          node && node.if_type? && !node.ternary? && !node.else?
         end
 
         def exit_body_type?(node)
-          _conditional, if_body, _else_body = *node
-          return false unless if_body
+          return false unless node.if_branch
 
-          EXIT_TYPES.include?(if_body.type)
+          EXIT_TYPES.include?(node.if_branch.type)
         end
 
         def offense_node(body)
@@ -112,7 +114,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            if modifier_if?(node)
+            if node.modifier_form?
               autocorrect_modifier(corrector, node)
             else
               autocorrect_block(corrector, node)

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

@@ -25,7 +25,6 @@ module RuboCop
       #  end
       class NonNilCheck < Cop
         include OnMethodDef
-        include IfNode
 
         def_node_matcher :not_equal_to_nil?, '(send _ :!= (:nil))'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
@@ -47,8 +46,8 @@ module RuboCop
 
         def unless_and_nil_check?(send_node)
           parent = send_node.parent
-          nil_check?(send_node) && unless_check?(parent) && !ternary?(parent) &&
-            parent.loc.keyword.is?('unless')
+          nil_check?(send_node) && unless_check?(parent) && !parent.ternary? &&
+            parent.unless?
         end
 
         def message(node)

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

@@ -5,8 +5,6 @@ module RuboCop
     module Style
       # This cop checks for uses if the keyword *not* instead of !.
       class Not < Cop
-        include IfNode
-
         MSG = 'Use `!` instead of `not`.'.freeze
 
         OPPOSITE_METHODS = {
@@ -45,7 +43,7 @@ module RuboCop
 
         def requires_parens?(child)
           child.and_type? || child.or_type? || child.binary_operation? ||
-            ternary?(child)
+            child.if_type? && child.ternary?
         end
 
         def correct_opposite_method(range, child)

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

@@ -25,7 +25,7 @@ module RuboCop
 
         private
 
-        def parameter_name
+        def max_parameter_name
           'MinDigits'
         end
 
@@ -39,7 +39,7 @@ module RuboCop
           case int
           when /^\d+$/
             add_offense(node, :expression) { self.max = int.size + 1 }
-          when /\d{4}/, /_\d{1,2}_/
+          when /\d{4}/, /_\d{1,2}(_|$)/
             add_offense(node, :expression) do
               self.config_to_allow_offenses = { 'Enabled' => false }
             end

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

@@ -12,15 +12,9 @@ module RuboCop
               'over `%s/then/else/end` constructs.'.freeze
 
         def on_normal_if_unless(node)
-          exp = node.source
-          return if exp.include?("\n")
+          return unless node.single_line? && node.else_branch
 
-          condition = exp.include?('if') ? 'if' : 'unless'
-          return unless node.loc.respond_to?(:else) &&
-                        node.loc.else &&
-                        else_branch_present?(node, condition)
-
-          add_offense(node, :expression, format(MSG, condition))
+          add_offense(node, :expression, format(MSG, node.keyword))
         end
 
         def autocorrect(node)
@@ -30,20 +24,23 @@ module RuboCop
         end
 
         def replacement(node)
-          return ternary(node) unless node.parent
-          return "(#{ternary(node)})" if [:and, :or].include?(node.parent.type)
+          return to_ternary(node) unless node.parent
+
+          if [:and, :or].include?(node.parent.type)
+            return "(#{to_ternary(node)})"
+          end
 
           if node.parent.send_type? && operator?(node.parent.method_name)
-            return "(#{ternary(node)})"
+            return "(#{to_ternary(node)})"
           end
 
-          ternary(node)
+          to_ternary(node)
         end
 
-        def ternary(node)
+        def to_ternary(node)
           cond, body, else_clause = *node
-          "#{expr_replacement(cond)} ? #{expr_replacement(body)} : " +
-            expr_replacement(else_clause)
+          "#{expr_replacement(cond)} ? #{expr_replacement(body)} : " \
+            "#{expr_replacement(else_clause)}"
         end
 
         def expr_replacement(node)
@@ -72,13 +69,6 @@ module RuboCop
 
           !parenthesized_call?(node)
         end
-
-        private
-
-        def else_branch_present?(node, condition)
-          _, if_branch, else_branch = *node
-          condition == 'if' ? else_branch : if_branch
-        end
       end
     end
   end

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

@@ -25,23 +25,12 @@ module RuboCop
         def on_args(node)
           *_but_last, last_arg = *node
 
-          # asserting that there was an argument at all
-          return unless last_arg
-
-          # asserting last argument is an optional argument
-          return unless last_arg.optarg_type?
+          return unless last_arg && last_arg.optarg_type?
 
           arg, default_value = *last_arg
 
-          # asserting default value is a hash
-          return unless default_value.hash_type?
-
-          # asserting default value is empty hash
-          *key_value_pairs = *default_value
-          return unless key_value_pairs.empty?
-
-          # Check for suspicious argument names
-          return unless name_in_suspicious_param_names?(arg)
+          return unless default_value.hash_type? && default_value.pairs.empty?
+          return unless suspicious_name?(arg)
 
           add_offense(last_arg, :expression, MSG)
         end
@@ -59,7 +48,7 @@ module RuboCop
 
         private
 
-        def name_in_suspicious_param_names?(arg_name)
+        def suspicious_name?(arg_name)
           cop_config.key?('SuspiciousParamNames') &&
             cop_config['SuspiciousParamNames'].include?(arg_name.to_s)
         end

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

@@ -23,8 +23,6 @@ module RuboCop
       #   b = 2
       #   c = 3
       class ParallelAssignment < Cop
-        include IfNode
-
         MSG = 'Do not use parallel assignment.'.freeze
 
         def on_masgn(node)
@@ -164,7 +162,7 @@ module RuboCop
 
         def modifier_statement?(node)
           node &&
-            ((node.if_type? && modifier_if?(node)) ||
+            ((node.if_type? && node.modifier_form?) ||
             ((node.while_type? || node.until_type?) && modifier_while?(node)))
         end
 

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

@@ -6,12 +6,12 @@ module RuboCop
       # This cop checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
       class ParenthesesAroundCondition < Cop
-        include IfNode
         include SafeAssignment
         include Parentheses
 
         def on_if(node)
-          return if ternary?(node)
+          return if node.ternary?
+
           process_control_op(node)
         end
 
@@ -26,31 +26,27 @@ module RuboCop
         private
 
         def process_control_op(node)
-          cond, _body = *node
+          cond = node.condition
 
           return unless cond.begin_type?
-          # handle `if () ...`
-          return if empty_condition?(cond)
-          # handle `if (something rescue something_else) ...`
+          return if cond.children.empty?
           return if modifier_op?(cond.children.first)
-          # check if there's any whitespace between the keyword and the cond
           return if parens_required?(node.children.first)
-          # allow safe assignment
           return if safe_assignment?(cond) && safe_assignment_allowed?
 
           add_offense(cond, :expression, message(node))
         end
 
         def modifier_op?(node)
-          return false if ternary?(node)
+          return false if node.if_type? && node.ternary?
           return true if node.rescue_type?
 
-          [:if, :while, :until].include?(node.type) &&
-            node.loc.end.nil?
+          MODIFIER_NODES.include?(node.type) &&
+            node.modifier_form?
         end
 
         def message(node)
-          kw = node.loc.keyword.source
+          kw = node.keyword
           article = kw == 'while' ? 'a' : 'an'
           "Don't use parentheses around the condition of #{article} `#{kw}`."
         end