rubocop 0.87.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,107 @@
+# 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))
+          end
+        end
+
+        def new_expression(inner_node)
+          outer_node = inner_node.parent
+
+          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,64 @@
+# 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))
+      #
+      #   # bad
+      #   method1(method2 arg)
+      class NestedParenthesizedCalls < Cop
+        include RangeHelp
+        include AllowedMethods
+
+        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.begin,
+                                         side: :left)
+
+          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? ||
+            allowed?(send_node)
+        end
+
+        def allowed?(send_node)
+          send_node.parent.arguments.one? &&
+            allowed_method?(send_node.method_name) &&
+            send_node.arguments.one?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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
+
+        def autocorrect(node)
+          if_node = if_node(node)
+
+          lambda do |corrector|
+            corrector.replace(if_node, <<~RUBY.chop)
+              if #{if_node.condition.source}
+                #{remove_parentheses(if_node.if_branch.source)}
+              else
+                #{if_node.else_branch.source}
+              end
+            RUBY
+          end
+        end
+
+        private
+
+        def if_node(node)
+          node = node.parent
+          return node if node.if_type?
+
+          if_node(node)
+        end
+
+        def remove_parentheses(source)
+          source.gsub(/\A\(/, '').gsub(/\)\z/, '')
+        end
+      end
+    end
+  end
+end