rubocop 0.75.1

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of if with a negated condition. Only ifs
+      # without else are considered. There are three different styles:
+      #
+      #   - both
+      #   - prefix
+      #   - postfix
+      #
+      # @example EnforcedStyle: both (default)
+      #   # enforces `unless` for `prefix` and `postfix` conditionals
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      # @example EnforcedStyle: prefix
+      #   # enforces `unless` for just `prefix` conditionals
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   bar if !foo
+      #
+      # @example EnforcedStyle: postfix
+      #   # enforces `unless` for just `postfix` conditionals
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      #   # good
+      #
+      #   if !foo
+      #     bar
+      #   end
+      class NegatedIf < Cop
+        include ConfigurableEnforcedStyle
+        include NegativeConditional
+
+        def on_if(node)
+          return if node.unless? || node.elsif? || node.ternary?
+          return if correct_style?(node)
+
+          check_negative_conditional(node)
+        end
+
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+        end
+
+        def correct_style?(node)
+          style == :prefix && node.modifier_form? ||
+            style == :postfix && !node.modifier_form?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of unless with a negated condition. Only unless
+      # without else are considered. There are three different styles:
+      #
+      #   - both
+      #   - prefix
+      #   - postfix
+      #
+      # @example EnforcedStyle: both (default)
+      #   # enforces `if` for `prefix` and `postfix` conditionals
+      #
+      #   # bad
+      #   unless !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   if foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   bar unless !foo
+      #
+      #   # good
+      #   bar if foo
+      #
+      # @example EnforcedStyle: prefix
+      #   # enforces `if` for just `prefix` conditionals
+      #
+      #   # bad
+      #   unless !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   if foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   bar unless !foo
+      #
+      # @example EnforcedStyle: postfix
+      #   # enforces `if` for just `postfix` conditionals
+      #
+      #   # bad
+      #   bar unless !foo
+      #
+      #   # good
+      #   bar if foo
+      #
+      #   # good
+      #   unless !foo
+      #     bar
+      #   end
+      class NegatedUnless < Cop
+        include ConfigurableEnforcedStyle
+        include NegativeConditional
+
+        def on_if(node)
+          return if node.if? || node.elsif? || node.ternary?
+          return if correct_style?(node)
+
+          check_negative_conditional(node)
+        end
+
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+        end
+
+        def correct_style?(node)
+          style == :prefix && node.modifier_form? ||
+            style == :postfix && !node.modifier_form?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of while with a negated condition.
+      #
+      # @example
+      #   # bad
+      #   while !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   until foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   bar until !foo
+      #
+      #   # good
+      #   bar while foo
+      #   bar while !foo && baz
+      class NegatedWhile < Cop
+        include NegativeConditional
+
+        def on_while(node)
+          check_negative_conditional(node)
+        end
+
+        def on_until(node)
+          check_negative_conditional(node)
+        end
+
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for nested use of if, unless, while and until in their
+      # modifier form.
+      #
+      # @example
+      #
+      #   # bad
+      #   something if a if b
+      #
+      #   # good
+      #   something if b && a
+      class NestedModifier < Cop
+        include RangeHelp
+
+        MSG = 'Avoid using nested modifiers.'
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        def on_if(node)
+          check(node)
+        end
+
+        def check(node)
+          return if part_of_ignored_node?(node)
+          return unless modifier?(node) && modifier?(node.parent)
+
+          add_offense(node, location: :keyword)
+          ignore_node(node)
+        end
+
+        def modifier?(node)
+          node&.basic_conditional? && node&.modifier_form?
+        end
+
+        def autocorrect(node)
+          return unless node.if_type? && node.parent.if_type?
+
+          range = range_between(node.loc.keyword.begin_pos,
+                                node.parent.condition.source_range.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, new_expression(node.parent, node))
+          end
+        end
+
+        def new_expression(outer_node, inner_node)
+          operator = replacement_operator(outer_node.keyword)
+          lh_operand = left_hand_operand(outer_node, operator)
+          rh_operand = right_hand_operand(inner_node, outer_node.keyword)
+
+          "#{outer_node.keyword} #{lh_operand} #{operator} #{rh_operand}"
+        end
+
+        def replacement_operator(keyword)
+          keyword == 'if' ? '&&' : '||'
+        end
+
+        def left_hand_operand(node, operator)
+          expr = node.condition.source
+          expr = "(#{expr})" if node.condition.or_type? &&
+                                operator == '&&'
+          expr
+        end
+
+        def right_hand_operand(node, left_hand_keyword)
+          condition = node.condition
+
+          expr = if condition.send_type? && !condition.arguments.empty? &&
+                    !condition.operator_method?
+                   add_parentheses_to_method_arguments(condition)
+                 else
+                   condition.source
+                 end
+          expr = "(#{expr})" if requires_parens?(condition)
+          expr = "!#{expr}" unless left_hand_keyword == node.keyword
+          expr
+        end
+
+        def add_parentheses_to_method_arguments(send_node)
+          expr = +''
+          expr << "#{send_node.receiver.source}." if send_node.receiver
+          expr << send_node.method_name.to_s
+          expr << "(#{send_node.arguments.map(&:source).join(', ')})"
+
+          expr
+        end
+
+        def requires_parens?(node)
+          node.or_type? ||
+            !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unparenthesized method calls in the argument list
+      # of a parenthesized method call.
+      #
+      # @example
+      #   # good
+      #   method1(method2(arg), method3(arg))
+      #
+      #   # bad
+      #   method1(method2 arg, method3, arg)
+      class NestedParenthesizedCalls < Cop
+        include RangeHelp
+
+        MSG = 'Add parentheses to nested method call `%<source>s`.'
+
+        def on_send(node)
+          return unless node.parenthesized?
+
+          node.each_child_node(:send, :csend) do |nested|
+            next if allowed_omission?(nested)
+
+            add_offense(nested,
+                        location: nested.source_range,
+                        message: format(MSG, source: nested.source))
+          end
+        end
+        alias on_csend on_send
+
+        def autocorrect(nested)
+          first_arg = nested.first_argument.source_range
+          last_arg = nested.last_argument.source_range
+
+          leading_space =
+            range_with_surrounding_space(range: first_arg,
+                                         side: :left).begin.resize(1)
+
+          lambda do |corrector|
+            corrector.replace(leading_space, '(')
+            corrector.insert_after(last_arg, ')')
+          end
+        end
+
+        private
+
+        def allowed_omission?(send_node)
+          !send_node.arguments? || send_node.parenthesized? ||
+            send_node.setter_method? || send_node.operator_method? ||
+            whitelisted?(send_node)
+        end
+
+        def whitelisted?(send_node)
+          send_node.parent.arguments.one? &&
+            whitelisted_methods.include?(send_node.method_name.to_s) &&
+            send_node.arguments.one?
+        end
+
+        def whitelisted_methods
+          cop_config['Whitelist'] || []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for nested ternary op expressions.
+      #
+      # @example
+      #   # bad
+      #   a ? (b ? b1 : b2) : a2
+      #
+      #   # good
+      #   if a
+      #     b ? b1 : b2
+      #   else
+      #     a2
+      #   end
+      class NestedTernaryOperator < Cop
+        MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
+              'constructs instead.'
+
+        def on_if(node)
+          return unless node.ternary?
+
+          node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
+            add_offense(nested_ternary)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `next` to skip iteration instead of a condition at the end.
+      #
+      # @example EnforcedStyle: skip_modifier_ifs (default)
+      #   # bad
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     next unless a == 1
+      #     puts a
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |o|
+      #     puts o unless o == 1
+      #   end
+      #
+      # @example EnforcedStyle: always
+      #   # With `always` all conditions at the end of an iteration needs to be
+      #   # replaced by next - with `skip_modifier_ifs` the modifier if like
+      #   # this one are ignored: `[1, 2].each { |a| return 'yes' if a == 1 }`
+      #
+      #   # bad
+      #   [1, 2].each do |o|
+      #     puts o unless o == 1
+      #   end
+      #
+      #   # bad
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     next unless a == 1
+      #     puts a
+      #   end
+      class Next < Cop
+        include ConfigurableEnforcedStyle
+        include MinBodyLength
+        include RangeHelp
+
+        MSG = 'Use `next` to skip iteration.'
+        EXIT_TYPES = %i[break return].freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::SafeNavigation]
+        end
+
+        def investigate(_processed_source)
+          # When correcting nested offenses, we need to keep track of how much
+          # we have adjusted the indentation of each line
+          @reindented_lines = Hash.new(0)
+        end
+
+        def on_block(node)
+          return unless node.send_node.send_type? &&
+                        node.send_node.enumerator_method?
+
+          check(node)
+        end
+
+        def on_while(node)
+          check(node)
+        end
+        alias on_until on_while
+        alias on_for on_while
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.modifier_form?
+              autocorrect_modifier(corrector, node)
+            else
+              autocorrect_block(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def check(node)
+          return unless node.body && ends_with_condition?(node.body)
+
+          offending_node = offense_node(node.body)
+
+          add_offense(offending_node,
+                      location: offense_location(offending_node))
+        end
+
+        def ends_with_condition?(body)
+          return true if simple_if_without_break?(body)
+
+          body.begin_type? && simple_if_without_break?(body.children.last)
+        end
+
+        def simple_if_without_break?(node)
+          return false unless if_without_else?(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? && !node.ternary? && !node.else?
+        end
+
+        def exit_body_type?(node)
+          return false unless node.if_branch
+
+          EXIT_TYPES.include?(node.if_branch.type)
+        end
+
+        def offense_node(body)
+          *_, condition = *body
+
+          condition&.if_type? ? condition : body
+        end
+
+        def offense_location(offense_node)
+          offense_begin_pos = offense_node.source_range.begin
+          offense_begin_pos.join(offense_node.condition.source_range)
+        end
+
+        def autocorrect_modifier(corrector, node)
+          body = node.if_branch || node.else_branch
+
+          replacement =
+            "next #{node.inverse_keyword} #{node.condition.source}\n" \
+            "#{' ' * node.source_range.column}#{body.source}"
+
+          corrector.replace(node.source_range, replacement)
+        end
+
+        def autocorrect_block(corrector, node)
+          next_code = "next #{node.inverse_keyword} #{node.condition.source}"
+
+          corrector.insert_before(node.source_range, next_code)
+
+          corrector.remove(cond_range(node, node.condition))
+          corrector.remove(end_range(node))
+
+          lines = reindentable_lines(node)
+
+          return if lines.empty?
+
+          reindent(lines, node.condition, corrector)
+        end
+
+        def cond_range(node, cond)
+          end_pos = if node.loc.begin
+                      node.loc.begin.end_pos # after "then"
+                    else
+                      cond.source_range.end_pos
+                    end
+
+          range_between(node.source_range.begin_pos, end_pos)
+        end
+
+        def end_range(node)
+          source_buffer = node.source_range.source_buffer
+          end_pos = node.loc.end.end_pos
+          begin_pos = node.loc.end.begin_pos - node.loc.end.column
+          begin_pos -= 1 if end_followed_by_whitespace_only?(source_buffer,
+                                                             end_pos)
+
+          range_between(begin_pos, end_pos)
+        end
+
+        def end_followed_by_whitespace_only?(source_buffer, end_pos)
+          source_buffer.source[end_pos..-1] =~ /\A\s*$/
+        end
+
+        def reindentable_lines(node)
+          buffer = node.source_range.source_buffer
+
+          # end_range starts with the final newline of the if body
+          lines = (node.source_range.line + 1)...node.loc.end.line
+          lines = lines.to_a - heredoc_lines(node)
+          # Skip blank lines
+          lines.reject { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
+        end
+
+        # Adjust indentation of `lines` to match `node`
+        def reindent(lines, node, corrector)
+          range  = node.source_range
+          buffer = range.source_buffer
+
+          target_indent = range.source_line =~ /\S/
+          delta = actual_indent(lines, buffer) - target_indent
+          lines.each do |lineno|
+            reindent_line(corrector, lineno, delta, buffer)
+          end
+        end
+
+        def actual_indent(lines, buffer)
+          lines.map { |lineno| buffer.source_line(lineno) =~ /\S/ }.min
+        end
+
+        def heredoc_lines(node)
+          node.each_node(:dstr)
+              .select(&:heredoc?)
+              .map { |n| n.loc.heredoc_body }
+              .flat_map { |b| (b.line...b.last_line).to_a }
+        end
+
+        def reindent_line(corrector, lineno, delta, buffer)
+          adjustment = delta + @reindented_lines[lineno]
+          @reindented_lines[lineno] = adjustment
+
+          if adjustment.positive?
+            corrector.remove_leading(buffer.line_range(lineno), adjustment)
+          elsif adjustment.negative?
+            corrector.insert_before(buffer.line_range(lineno),
+                                    ' ' * -adjustment)
+          end
+        end
+      end
+    end
+  end
+end