rubocop 0.42.0 → 0.43.0

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

@@ -81,6 +81,7 @@ 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)
@@ -155,9 +156,8 @@ module RuboCop
                     else
                       cond.source_range.end_pos
                     end
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.source_range.begin_pos,
-                                    end_pos)
+
+          range_between(node.source_range.begin_pos, end_pos)
         end
 
         def end_range(node)
@@ -167,7 +167,7 @@ module RuboCop
           begin_pos -= 1 if end_followed_by_whitespace_only?(source_buffer,
                                                              end_pos)
 
-          Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+          range_between(begin_pos, end_pos)
         end
 
         def end_followed_by_whitespace_only?(source_buffer, end_pos)

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

@@ -33,15 +33,24 @@ module RuboCop
           return if ignored_node?(node)
           receiver, method, args = *node
 
-          if method == :!=
-            add_offense(node, :selector) if args == NIL_NODE
-          elsif method == :! && include_semantic_changes?
-            add_offense(node, :expression) if nil_check?(receiver)
+          if not_equal_to_nil?(method, args)
+            add_offense(node, :selector)
+          elsif include_semantic_changes? &&
+                not_and_nil_check?(method, receiver)
+            add_offense(node, :expression)
           end
         end
 
         private
 
+        def not_equal_to_nil?(method, args)
+          method == :!= && args == NIL_NODE
+        end
+
+        def not_and_nil_check?(method, receiver)
+          method == :! && nil_check?(receiver)
+        end
+
         def message(node)
           _receiver, method, _args = *node
           if method == :!=
@@ -57,18 +66,17 @@ module RuboCop
 
         def on_method_def(_node, name, _args, body)
           # only predicate methods are handled differently
-          return unless name.to_s.end_with?('?')
-          return unless body
+          return unless name.to_s.end_with?('?') && body
 
-          if body.type != :begin
-            ignore_node(body)
-          elsif body.type == :begin
+          if body.begin_type?
             ignore_node(body.children.last)
+          else
+            ignore_node(body)
           end
         end
 
         def nil_check?(node)
-          return false unless node && node.type == :send
+          return false unless node && node.send_type?
 
           _receiver, method, *_args = *node
           method == :nil?

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

@@ -47,12 +47,20 @@ module RuboCop
         def literal_type(node)
           literal = integer_part(node)
 
+          octal_literal_type(literal) || hex_bin_dec_literal_type(literal)
+        end
+
+        def octal_literal_type(literal)
+          # rubocop:disable Style/GuardClause
           if literal =~ OCTAL_ZERO_ONLY_REGEX && octal_zero_only?
             return :octal_zero_only
           elsif literal =~ OCTAL_REGEX && !octal_zero_only?
             return :octal
           end
+          # rubocop:enable Style/GuardClause
+        end
 
+        def hex_bin_dec_literal_type(literal)
           case literal
           when HEX_REGEX
             :hex

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

@@ -4,8 +4,8 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for using of comparison operators (`==`, `!=`,
-      # `>`, `<`), to test numbers as zero, nonzero, positive, or negative.
+      # This cop checks for usage of comparison operators (`==`, `!=`,
+      # `>`, `<`) to test numbers as zero, nonzero, positive, or negative.
       # These can be replaced by their respective predicate methods.
       # The cop can also be configured to do the reverse.
       #
@@ -59,10 +59,10 @@ module RuboCop
         def on_send(node)
           numeric, replacement = check(node)
 
-          if numeric
-            add_offense(node, node.loc.expression,
-                        format(MSG, replacement, node.source))
-          end
+          return unless numeric
+
+          add_offense(node, node.loc.expression,
+                      format(MSG, replacement, node.source))
         end
 
         private
@@ -75,9 +75,9 @@ module RuboCop
               predicate(node)
             end
 
-          if numeric && operator && replacement_supported?(operator)
-            return numeric, replacement(numeric, operator)
-          end
+          return unless numeric && operator && replacement_supported?(operator)
+
+          [numeric, replacement(numeric, operator)]
         end
 
         def autocorrect(node)

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

@@ -15,8 +15,11 @@ module RuboCop
         def on_normal_if_unless(node)
           exp = node.source
           return if exp.include?("\n")
-          return unless node.loc.respond_to?(:else) && node.loc.else
+
           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))
         end
@@ -70,6 +73,13 @@ 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/op_method.rb

@@ -31,7 +31,7 @@ module RuboCop
                         args.children.one? &&
                         !TARGET_ARGS.include?(args)
 
-          add_offense(args.children[0], :expression, format(MSG, name))
+          add_offense(args.children.first, :expression, format(MSG, name))
         end
 
         def op_method?(name)

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

@@ -48,14 +48,14 @@ module RuboCop
         end
 
         def validate_config
-          if target_ruby_version < 2.0
-            raise ValidationError, 'The `Style/OptionHash` cop is only ' \
-                                  'compatible with Ruby 2.0 and up, but the ' \
-                                  'target Ruby version for your project is ' \
-                                  "1.9.\nPlease disable this cop or adjust " \
-                                  'the `TargetRubyVersion` parameter in your ' \
-                                  'configuration.'
-          end
+          return unless target_ruby_version < 2.0
+
+          raise ValidationError, 'The `Style/OptionHash` cop is only ' \
+                                'compatible with Ruby 2.0 and up, but the ' \
+                                'target Ruby version for your project is ' \
+                                "1.9.\nPlease disable this cop or adjust " \
+                                'the `TargetRubyVersion` parameter in your ' \
+                                'configuration.'
         end
 
         private

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

@@ -25,25 +25,38 @@ module RuboCop
         def on_def(node)
           _method, arguments, = *node
           arguments = *arguments
-          optarg_positions = []
-          arg_positions = []
 
-          arguments.each_with_index do |argument, index|
-            optarg_positions << index if argument.optarg_type?
-            arg_positions << index if argument.arg_type?
+          each_misplaced_optional_arg(arguments) do |argument|
+            arg, = *argument
+            add_offense(argument, :expression, format(MSG, arg))
           end
+        end
+
+        private
 
+        def each_misplaced_optional_arg(arguments)
+          optarg_positions, arg_positions = argument_positions(arguments)
           return if optarg_positions.empty? || arg_positions.empty?
 
           optarg_positions.each do |optarg_position|
             # there can only be one group of optional arguments
             break if optarg_position > arg_positions.max
-            argument = arguments[optarg_position]
-            arg, = *argument
 
-            add_offense(argument, :expression, format(MSG, arg))
+            yield arguments[optarg_position]
           end
         end
+
+        def argument_positions(arguments)
+          optarg_positions = []
+          arg_positions = []
+
+          arguments.each_with_index do |argument, index|
+            optarg_positions << index if argument.optarg_type?
+            arg_positions << index if argument.arg_type?
+          end
+
+          [optarg_positions, arg_positions]
+        end
       end
     end
   end

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

@@ -29,30 +29,43 @@ module RuboCop
         MSG = 'Do not use parallel assignment.'.freeze
 
         def on_masgn(node)
-          left, right = *node
-          left_elements = *left
-          right_elements = [*right].compact # edge case for one constant
+          lhs, rhs = *node
+          lhs_elements = *lhs
+          rhs_elements = [*rhs].compact # edge case for one constant
 
-          # only complain when the number of variables matches
-          return if left_elements.size != right_elements.size
+          return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
+                    allowed_masign?(lhs_elements, rhs_elements)
 
-          # account for edge cases using one variable with a comma
-          return if left_elements.size == 1
+          add_offense(node, :expression)
+        end
+
+        private
+
+        def allowed_masign?(lhs_elements, rhs_elements)
+          lhs_elements.size != rhs_elements.size ||
+            !find_valid_order(lhs_elements, rhs_elements)
+        end
 
-          # account for edge case of Constant::CONSTANT
-          return unless right.array_type?
+        def allowed_lhs?(node)
+          elements = *node
 
-          # allow mass assignment as the return of a method call
-          return if right.block_type? || right.send_type?
+          # Account for edge cases using one variable with a comma
+          # E.g.: `foo, = *bar`
+          elements.one? || elements.any?(&:splat_type?)
+        end
 
-          # allow mass assignment when using splat
-          return if (left_elements + right_elements).any?(&:splat_type?)
+        def allowed_rhs?(node)
+          # Edge case for one constant
+          elements = [*node].compact
 
-          order = find_valid_order(left_elements, right_elements)
-          # For `a, b = b, a` or similar, there is no valid order
-          return if order.nil?
+          # Account for edge case of `Constant::CONSTANT`
+          !node.array_type? ||
+            return_of_method_call?(node) ||
+            elements.any?(&:splat_type?)
+        end
 
-          add_offense(node, :expression)
+        def return_of_method_call?(node)
+          node.block_type? || node.send_type?
         end
 
         def autocorrect(node)
@@ -61,22 +74,22 @@ module RuboCop
             left_elements = *left
             right_elements = [*right].compact
             order = find_valid_order(left_elements, right_elements)
+            correction = assignment_corrector(node, order)
 
-            assignment_corrector =
-              if modifier_statement?(node.parent)
-                ModifierCorrector.new(node, config, order)
-              elsif rescue_modifier?(node.parent)
-                RescueCorrector.new(node, config, order)
-              else
-                GenericCorrector.new(node, config, order)
-              end
-
-            corrector.replace(assignment_corrector.correction_range,
-                              assignment_corrector.correction)
+            corrector.replace(correction.correction_range,
+                              correction.correction)
           end
         end
 
-        private
+        def assignment_corrector(node, order)
+          if modifier_statement?(node.parent)
+            ModifierCorrector.new(node, config, order)
+          elsif rescue_modifier?(node.parent)
+            RescueCorrector.new(node, config, order)
+          else
+            GenericCorrector.new(node, config, order)
+          end
+        end
 
         def find_valid_order(left_elements, right_elements)
           # arrange left_elements in an order such that no corresponding right
@@ -247,12 +260,7 @@ module RuboCop
           def correction
             parent = node.parent
 
-            modifier_range =
-              Parser::Source::Range.new(parent.source_range.source_buffer,
-                                        parent.loc.keyword.begin_pos,
-                                        parent.source_range.end_pos)
-
-            "#{modifier_range.source}\n" \
+            "#{modifier_range(parent).source}\n" \
               "#{indentation(node)}" \
               "#{assignment.join("\n#{indentation(node)}")}" \
               "\n#{offset(node)}end"
@@ -261,6 +269,14 @@ module RuboCop
           def correction_range
             node.parent.source_range
           end
+
+          private
+
+          def modifier_range(node)
+            Parser::Source::Range.new(node.source_range.source_buffer,
+                                      node.loc.keyword.begin_pos,
+                                      node.source_range.end_pos)
+          end
         end
       end
     end

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

@@ -29,7 +29,7 @@ module RuboCop
         def process_control_op(node)
           cond, _body = *node
 
-          return unless cond.type == :begin
+          return unless cond.begin_type?
           # handle `if (something rescue something_else) ...`
           return if modifier_op?(cond.children.first)
           # check if there's any whitespace between the keyword and the cond
@@ -42,7 +42,7 @@ module RuboCop
 
         def modifier_op?(node)
           return false if ternary?(node)
-          return true if node.type == :rescue
+          return true if node.rescue_type?
 
           [:if, :while, :until].include?(node.type) &&
             node.loc.end.nil?

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

@@ -76,7 +76,7 @@ module RuboCop
         def string_source(node)
           if node.is_a?(String)
             node
-          elsif node.respond_to?(:type) && node.type == :str
+          elsif node.respond_to?(:type) && node.str_type?
             node.source
           end
         end

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

@@ -106,10 +106,10 @@ module RuboCop
         def check_exploded(node)
           _receiver, selector, *args = *node
 
-          if args.size == 1
+          if args.one?
             arg, = *args
 
-            if arg.type == :send && arg.loc.selector.is?('new')
+            if arg.send_type? && arg.loc.selector.is?('new')
               _receiver, _selector, *constructor_args = *arg
 
               # Allow code like `raise Ex.new(arg1, arg2)`.

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

@@ -31,7 +31,7 @@ module RuboCop
         MSG = 'Redundant `begin` block detected.'.freeze
 
         def on_method_def(_node, _method_name, _args, body)
-          return unless body && body.type == :kwbegin
+          return unless body && body.kwbegin_type?
 
           add_offense(body, :begin)
         end

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

@@ -32,31 +32,33 @@ module RuboCop
         end
 
         def parens_allowed?(node)
-          # don't flag `()`
           empty_parentheses?(node) ||
-            # don't flag `break(1)`, etc
-            (keyword_ancestor?(node) && parens_required?(node)) ||
-            # don't flag `method ({key: value})`
+            allowed_ancestor?(node) ||
             hash_literal_as_first_arg?(node) ||
-            # don't flag `rescue(ExceptionClass)`
             rescue?(node) ||
-            # don't flag `method (arg) { }`
-            (arg_in_call_with_block?(node) && !parentheses?(node.parent)) ||
-            # don't flag
-            # ```
-            # { a: (1
-            #      ), }
-            # ```
+            allowed_method_call?(node) ||
             allowed_array_or_hash_element?(node)
         end
 
+        def allowed_ancestor?(node)
+          # Don't flag `break(1)`, etc
+          keyword_ancestor?(node) && parens_required?(node)
+        end
+
+        def allowed_method_call?(node)
+          # Don't flag `method (arg) { }`
+          arg_in_call_with_block?(node) && !parentheses?(node.parent)
+        end
+
         def empty_parentheses?(node)
+          # Don't flag `()`
           node.children.empty?
         end
 
         def hash_literal_as_first_arg?(node)
-          child = node.children.first
-          child.hash_type? && first_arg?(node) && !parentheses?(node.parent)
+          # Don't flag `method ({key: value})`
+          node.children.first.hash_type? && first_arg?(node) &&
+            !parentheses?(node.parent)
         end
 
         def check(begin_node)
@@ -100,6 +102,11 @@ module RuboCop
         end
 
         def allowed_array_or_hash_element?(node)
+          # Don't flag
+          # ```
+          # { a: (1
+          #      ), }
+          # ```
           (hash_element?(node) || array_element?(node)) &&
             only_closing_paren_before_comma?(node)
         end
@@ -129,7 +136,7 @@ module RuboCop
 
           args = *node
 
-          if args.size == 1 && args.first && args.first.begin_type?
+          if only_begin_arg?(args)
             parentheses?(args.first)
           else
             args.empty? || parentheses?(node)
@@ -146,6 +153,10 @@ module RuboCop
           args.empty? || parentheses?(send_node) || square_brackets?(send_node)
         end
 
+        def only_begin_arg?(args)
+          args.size == 1 && args.first && args.first.begin_type?
+        end
+
         def first_arg?(node)
           send_node = node.parent
           return false unless send_node && send_node.send_type?